#include <QCoreApplication>
#include<iostream>
#include<QDebug>
#include<QThread>
#include<QMutex>
#include<QMutexLocker>
class LazySingleton;
  QMutex mutex;
//单例模式：保证一些类只有一个实例
//经典饿汉式：线程不安全
class LazySingleton{
private:
    static LazySingleton*instance;
    //私有构造函数式关键
    LazySingleton()
    {
        qDebug()<<"LazySingleton";
    }

    // 必须禁用拷贝构造和赋值操作符
    LazySingleton(const LazySingleton&) = delete;
    LazySingleton& operator=(const LazySingleton&) = delete;
    void Resources()
    {
        qDebug()<<"调用资源";
    }
public:
    static LazySingleton*getInstance()
    {
        if(instance==nullptr)
        { mutex.lock();//通过锁的方式来避免创建多个实例
            if(instance==nullptr)
            {instance= new LazySingleton();}
           mutex.unlock();
            // QThread::msleep(10);  // 10毫秒延迟，让更多线程能进入这个区域
            // instance= new LazySingleton();
            //instance->Resources();
        }
        return instance;
    }

};


LazySingleton* LazySingleton::instance=nullptr;
class EagerSingleton{//线程安全，即使不创建这个类，也会开空间，浪费资源
private:
    static EagerSingleton*instance;
    //私有构造函数式关键
    EagerSingleton()
    {
        qDebug()<<"LazySingleton";
    }

    // 必须禁用拷贝构造和赋值操作符
    EagerSingleton(const EagerSingleton&) = delete;
   EagerSingleton& operator=(const EagerSingleton&) = delete;
    void Resources()
    {
        qDebug()<<"调用资源";
    }
public:
    static EagerSingleton*getInstance()
    {

        return instance;
    }

};

EagerSingleton* EagerSingleton::instance=new EagerSingleton();

class MeyersSingleton {
private:
    MeyersSingleton() {
        qDebug() << "MeyersSingleton 创建（线程安全）" ;
    }

    MeyersSingleton(const MeyersSingleton&) = delete;
    MeyersSingleton& operator=(const MeyersSingleton&) = delete;

public:
    // 返回引用而不是指针，更安全
    static MeyersSingleton& getInstance() {
        static MeyersSingleton instance;  // C++11保证线程安全
        return instance;
    }

    void businessMethod() {
        qDebug()<< "MeyersSingleton 业务方法" ;
    }

    // 不需要手动释放，静态变量会自动析构
};
class WorkerThread : public QThread {
protected:
    void run() override {

        qDebug() <<&MeyersSingleton::getInstance();
    }
};
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    const int THREAD_COUNT = 10;
    QVector<WorkerThread*> threads;

    // 1. 先创建所有线程
    for (int i = 0; i < THREAD_COUNT; i++) {
        threads.append(new WorkerThread());
    }

    // 2. 然后几乎同时启动所有线程
    for (int i = 0; i < THREAD_COUNT; i++) {
        threads[i]->start();
        // 不调用wait()，让线程并发执行
    }

    qDebug() << "所有线程已启动，等待3秒让它们执行完成...";

    // 3. 等待一段时间让所有线程完成
    QThread::sleep(3);

    // 4. 清理线程
    for (int i = 0; i < THREAD_COUNT; i++) {
        if (threads[i]->isRunning()) {
            threads[i]->terminate();  // 强制终止（不推荐在生产环境使用）
        }
        threads[i]->wait();
        delete threads[i];
    }

    qDebug() << "=== 测试完成 ===";


    return a.exec();
}
